package com.controladores.controlvehicular;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import com.controladores.controlvehicular.R;
import com.controladores.controlvehicular.basededatos.GestorBaseDatos;
import android.util.Log;
import android.view.KeyEvent;
import android.view.Window;
import android.widget.TextView;
import android.widget.Toast;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.graphics.Typeface;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Environment;
/**
 * Clase inicial de la aplicación
 * @author Luis Soto <lsantoniosoto@gmail.com>
 * @author Mariuxi Salinas <mariuxidelcisne@gmail.com>
 * @version 1.0, 11/04/2014
 */
public class Main extends Activity {
	private long ms = 0;
	private long tiempoEspera = 2000;
	private boolean pantallaBiembenidaHabilitada = true;
	private boolean pausa = false;
	protected TextView etiquetaFuenteIU;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		this.requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);
		inicializarComponentes();
		fijarEstiloFuente();
		crearArchivoConfiguracion();
		crearPantallaBienbenida();
	}
	/**
	 * Inicializa los componentes para la interfaz
	 */
	private void inicializarComponentes() {
		etiquetaFuenteIU = (TextView) findViewById(R.id.tvNomProgramaS);
	}
	/**
	 * Fija el estilo de fuente a etiquetas de la interfaz
	 */
	public void fijarEstiloFuente() {
		Typeface tipofuente = Typeface.createFromAsset(getAssets(),
				"gloriahallelujah.ttf");
		etiquetaFuenteIU.setTypeface(tipofuente);
	}
	/**
	 * Crea pantalla de bienbenida de la interfaz Inicio Sesión 
	 */
	public void crearPantallaBienbenida() {
		Thread mythread = new Thread() {
			public void run() {
				try {
					while (pantallaBiembenidaHabilitada && ms < tiempoEspera) {
						if (!pausa)
							ms = ms + 100;
						sleep(100);
					}
				} catch (Exception e) {
				} finally {
					Intent intent = new Intent(Main.this, InicioSesion.class);
					startActivity(intent);
				}
			}
		};
		mythread.start();
	}
/**
 * Crea y lee archivo de configuración de conexion
 */
	public void crearArchivoConfiguracion() {

		GestorBaseDatos crear = new GestorBaseDatos(Main.this);
		try {
			crear.crearDataBase();
			crear.close();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		File root = Environment.getExternalStorageDirectory();
		File dir = new File(root + "/Android/data");
		File datafile = new File(dir, "configTCP.txt");
		if (datafile.exists()) {
			// Si ya existe no hacemos nada
			System.out.println("fichero ya existe");
			try {
				crear.abrirBaseDatos();
				crear.eliminarIp();
				crear.eliminarPuerto();
				crear.close();
			} catch (Exception ex) {
				// TODO Auto-generated catch block
				ex.printStackTrace();
			}

			try {
				File f = new File(dir.getAbsolutePath(), "configTCP.txt");

				BufferedReader fin = new BufferedReader(new InputStreamReader(
						new FileInputStream(f)));

				String texto = fin.readLine();
				fin.close();
				String[] datosConexion = descomponerCadenaConexión(texto, ":");
				String ip = datosConexion[0];
				String port = datosConexion[1];
				int puerto = Integer.parseInt(port);
				try {
					guardarConexion(ip, puerto);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println("error conexión ingreso");
				}

				System.out.println("texto encontrado " + texto);
			} catch (Exception ex) {
				Log.e("Ficheros", "Error al leer fichero desde tarjeta SD");
			}
		} else {
			try {
				if (root.canWrite()) {
					System.out.println(" despues escritura");

					FileWriter datawriter = new FileWriter(datafile);
					BufferedWriter out = new BufferedWriter(datawriter);
					String ip = "186.42.129.111";  
					String port = "3038";
					out.write(ip + ":" + port);
					out.close();
					int puerto = Integer.parseInt(port);
					try {
						guardarConexion(ip, puerto);
					} catch (Exception e2) {
						// TODO: handle exception
						System.out.println("error conexión ingreso");
					}
				}

			} catch (Exception ex) {
				Log.e("Ficheros", "Error al escribir fichero a tarjeta SD" + ex);
			}
		}
	}

	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		try {
			if (keyCode == KeyEvent.KEYCODE_BACK) {
				moveTaskToBack(true);
				return true;
			}

		} catch (Exception e) {
			// TODO: handle exception
			Toast.makeText(getBaseContext(), "Error al ir Atrás" + e,
					Toast.LENGTH_LONG).show();
		}
		return super.onKeyDown(keyCode, event);
	}
/**
 * Desconpone la cadena de conexion
 * @param cadena Datos de Conexión
 * @param separador Cararacter de separador de cadena  
 * @return String[] elementos de la cadena
 */
	public String[] descomponerCadenaConexión(String cadena, String separador) {
		String[] elementos = cadena.split(separador);
		return elementos;
	}

/*	public String recibirDatosConexion(File data) {
		String datosConexion = "";
		try {
			FileInputStream fileIN = new FileInputStream(data);
			BufferedReader buffer = new BufferedReader(new InputStreamReader(
					fileIN));
			datosConexion = new String();
			while ((datosConexion = buffer.readLine()) != null) {
				Log.v(getClass().getName() + "Linea: ", datosConexion);
				//Toast.makeText(getApplicationContext(), "string " + datosConexion,
				//		Toast.LENGTH_LONG).show();
			}
			buffer.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return datosConexion;
	}
*/
	/**
	 * Guarda la ip y puerto en la base de datos 
	 * @param ip dirección ip conexión  
	 * @param puerto número de puerto de conexión
	 */
	public void guardarConexion(String ip, int puerto) {
		GestorBaseDatos manejador = new GestorBaseDatos(Main.this);
		boolean bienHecho2 = false;
		try {

			manejador.abrirBaseDatos();
			bienHecho2 = manejador.insertarIpPuerto(ip, puerto,obtenerMac());
			
			manejador.close();
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println("se se guardo");

		}
		if (!bienHecho2) {
			System.out.println("La Datos no fueron Cargados de IP y PUERTO");

		}
		if (bienHecho2) {
			System.out.println("La Datos fueron Cargados de IP y PUERTO");
		}

	}
/**
 * Obtiene la mac del dispositivo
 * @return String direccionMac retorna la direccion mac
 */
	public  String obtenerMac() {
		WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
		WifiInfo wInfo = wifiManager.getConnectionInfo();
		String direccionMac = wInfo.getMacAddress();
		return direccionMac;
	}
// esto me toca revisar para la comunicacion no salga revisar
	/*public Boolean isNetworkAvailable() {
		ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo activeNetworkInfo = connectivityManager
				.getActiveNetworkInfo();
		return activeNetworkInfo != null
				&& activeNetworkInfo.isConnectedOrConnecting();
	}*/
/**
 * Verifica si existe respuesta del conexion 
 * @return Boolean respuestaConexion 
 */
	public Boolean respuestaEnLinea() {
		boolean respuestaConexion = false;
		try {
			Process p1 = java.lang.Runtime.getRuntime().exec(
					"ping -c 1 www.google.com");
			int existeComunicación = p1.waitFor();
			respuestaConexion = (existeComunicación == 0);
		} catch (Exception e) {
			// TODO Auto-generated catch block e.printStackTrace(); } return
			// false; }
		}
		return respuestaConexion;
	}
/**
 * verifica el estado en linea de la red
 * @return Boolean retorna el estado en linea o fuera de linea
 */
	public boolean verificarEstadoEnLinea() {
		ConnectivityManager CManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo NInfo = CManager.getActiveNetworkInfo();
		if (NInfo != null && NInfo.isConnectedOrConnecting()) {
			return true;
		}
		return false;
	}
}
